import http from './http'

/**
 * 获取所有健身目标
 * @returns {Promise} 所有健身目标列表
 */
export function getAllFitnessGoals() {
  console.log('API - 请求获取所有健身目标');
  
  // 检查认证头信息
  const headers = http.defaults.headers;
  console.log('API - 请求头信息:', headers);
  
  return http.get('/api/fitness-goals')
    .then(response => {
      // 记录完整响应
      console.log('API - 完整响应对象:', response);
      
      // 处理各种可能的响应格式
      let goals = [];
      
      // 由于axios拦截器已返回response.data，这里处理直接返回的数据
      if (Array.isArray(response)) {
        // 响应直接是数组
        goals = response;
        console.log('API - 返回的健身目标是数组，长度:', goals.length);
      } else if (response && response.content && Array.isArray(response.content)) {
        // 响应是包含content数组的对象
        goals = response.content;
        console.log('API - 返回的健身目标是分页对象，内容长度:', goals.length);
      } else if (response && typeof response === 'object') {
        // 可能是单个对象或其他格式
        console.log('API - 返回的健身目标是对象格式:', response);
        
        if (response.id) {
          // 单个目标对象
          goals = [response];
        } else {
          // 尝试从对象中提取可能的数组
          const possibleArrays = Object.values(response).filter(value => Array.isArray(value));
          if (possibleArrays.length > 0) {
            goals = possibleArrays[0];
            console.log('API - 从对象中提取数组，长度:', goals.length);
          }
        }
      } else {
        console.warn('API - 无法识别的响应格式:', response);
      }
      
      console.log('API - 处理后的健身目标数据:', {
        总数: goals.length || 0,
        示例: goals.length > 0 ? goals[0] : '无数据'
      });
      
      // 处理每个目标的日期格式
      goals.forEach(goal => {
        ['startDate', 'targetDate', 'completedDate'].forEach(dateField => {
          if (goal[dateField] && typeof goal[dateField] === 'string' && goal[dateField].includes('T')) {
            goal[dateField] = goal[dateField].replace('T', ' ').substring(0, 19);
          }
        });
      });
      
      return goals;
    })
    .catch(error => {
      console.error('API - 获取健身目标失败:', {
        状态码: error.response ? error.response.status : '无状态码',
        错误信息: error.message,
        响应数据: error.response ? error.response.data : '无响应数据',
        请求配置: error.config
      });
      
      // 返回空数组，避免前端崩溃
      return [];
    });
}

/**
 * 获取健身目标列表
 * @param {Object} params 查询参数
 * @returns {Promise} 健身目标列表
 */
export function getFitnessGoals(params) {
  return http.get('/api/fitness-goals', { params })
}

/**
 * 根据状态获取健身目标列表
 * @param {string} status 健身目标状态（ACTIVE/COMPLETED/FAILED/ABANDONED）
 * @returns {Promise} 健身目标列表
 */
export function getFitnessGoalsByStatus(status) {
  console.log('API - 根据状态获取健身目标:', status);
  
  return http.get(`/api/fitness-goals/by-status/${status}`)
    .then(response => {
      console.log('API - 状态查询响应:', response);
      
      // 处理各种可能的响应格式
      let goals = [];
      
      // 由于axios拦截器已返回response.data，这里处理直接返回的数据
      if (Array.isArray(response)) {
        // 响应直接是数组
        goals = response;
        console.log(`API - 状态${status}的目标是数组，长度:`, goals.length);
      } else if (response && response.content && Array.isArray(response.content)) {
        // 响应是包含content数组的对象
        goals = response.content;
        console.log(`API - 状态${status}的目标是分页对象，内容长度:`, goals.length);
      } else if (response && typeof response === 'object') {
        // 可能是单个对象或其他格式
        console.log(`API - 状态${status}的目标是对象格式:`, response);
        
        if (response.id) {
          // 单个目标对象
          goals = [response];
        } else {
          // 尝试从对象中提取可能的数组
          const possibleArrays = Object.values(response).filter(value => Array.isArray(value));
          if (possibleArrays.length > 0) {
            goals = possibleArrays[0];
            console.log(`API - 状态${status}的目标从对象提取数组，长度:`, goals.length);
          }
        }
      } else {
        console.warn(`API - 状态${status}的目标无法识别响应格式:`, response);
      }
      
      console.log('API - 处理后的健身目标数据:', {
        状态: status,
        总数: goals.length || 0,
        示例: goals.length > 0 ? goals[0] : '无数据'
      });
      
      // 处理每个目标的日期格式
      goals.forEach(goal => {
        ['startDate', 'targetDate', 'completedDate'].forEach(dateField => {
          if (goal[dateField] && typeof goal[dateField] === 'string' && goal[dateField].includes('T')) {
            goal[dateField] = goal[dateField].replace('T', ' ').substring(0, 19);
          }
        });
      });
      
      return goals;
    })
    .catch(error => {
      console.error('API - 根据状态获取健身目标失败:', {
        状态: status,
        状态码: error.response ? error.response.status : '无状态码',
        错误信息: error.message,
        响应数据: error.response ? error.response.data : '无响应数据'
      });
      
      // 返回空数组，避免前端崩溃
      return [];
    });
}

/**
 * 根据类型获取健身目标列表
 * @param {string} type 健身目标类型
 * @returns {Promise} 健身目标列表
 */
export function getFitnessGoalsByType(type) {
  return http.get(`/api/fitness-goals/by-type/${type}`)
}

/**
 * 获取健身目标详情
 * @param {number} id 健身目标ID
 * @returns {Promise} 健身目标详情
 */
export function getFitnessGoal(id) {
  return http.get(`/api/fitness-goals/${id}`)
}

/**
 * 获取健身目标详情
 * @param {number} id 健身目标ID
 * @returns {Promise} 健身目标详情
 */
export function getFitnessGoalById(id) {
  console.log('API - 请求健身目标详情, ID:', id);
  
  return http.get(`/api/fitness-goals/${id}`)
    .then(response => {
      // 处理响应数据
      const responseData = response.data !== undefined ? response.data : response;
      
      console.log('API - 健身目标详情获取成功:', {
        数据类型: typeof responseData,
        ID: responseData.id,
        标题: responseData.title,
        类型: responseData.type
      });
      
      // 处理日期格式（标准化）
      if (responseData.startDate && typeof responseData.startDate === 'string' && responseData.startDate.includes('T')) {
        responseData.startDate = responseData.startDate.replace('T', ' ').substring(0, 19);
      }
      
      if (responseData.targetDate && typeof responseData.targetDate === 'string' && responseData.targetDate.includes('T')) {
        responseData.targetDate = responseData.targetDate.replace('T', ' ').substring(0, 19);
      }
      
      if (responseData.completedDate && typeof responseData.completedDate === 'string' && responseData.completedDate.includes('T')) {
        responseData.completedDate = responseData.completedDate.replace('T', ' ').substring(0, 19);
      }
      
      return responseData;
    })
    .catch(error => {
      // 详细记录错误信息
      const errorDetails = {
        状态码: error.response ? error.response.status : '无状态码',
        错误信息: error.message,
        错误类型: error.name,
        响应数据: error.response ? JSON.stringify(error.response.data) : '无响应数据',
        请求ID: id
      };
      
      console.error('API - 获取健身目标详情失败:', errorDetails);
      
      // 如果是服务器内部错误且可能与Hibernate相关，给出更具体的提示
      if (error.response?.status === 500) {
        const errorMsg = error.response?.data?.message || '';
        if (errorMsg.includes('Hibernate') || errorMsg.includes('lazy') || 
            errorMsg.includes('proxy') || errorMsg.includes('serialize')) {
          console.warn('API - 可能是Hibernate懒加载序列化问题，请检查后端实体关系配置');
        }
      }
      
      throw error;
    });
}

/**
 * 创建健身目标
 * @param {Object} data 健身目标数据
 * @returns {Promise} 创建结果
 */
export function createFitnessGoal(data) {
  console.log('API - 创建健身目标, 数据:', data);
  
  // 确保数据格式正确
  const processedData = { ...data };
  
  // 处理日期格式 - 使用符合后端@JsonFormat注解的格式
  ['startDate', 'targetDate', 'completedDate'].forEach(dateField => {
    if (processedData[dateField]) {
      try {
        // 确保日期是符合后端预期的格式 (yyyy-MM-dd HH:mm:ss)
        let dateStr = processedData[dateField];
        if (typeof dateStr === 'string') {
          // 处理带T的ISO格式
          if (dateStr.includes('T')) {
            dateStr = dateStr.replace('T', ' ').split('.')[0];
          }
          
          // 规范化日期格式
          const dateParts = dateStr.trim().split(' ');
          if (dateParts.length === 2) {
            processedData[dateField] = `${dateParts[0]} ${dateParts[1]}`;
          }
        }
      } catch (e) {
        console.warn(`API - 日期格式转换失败(${dateField}):`, e);
      }
    }
  });
  
  // 后端需要user对象，但前端不需要发送
  if (processedData.user) {
    delete processedData.user;
  }
  
  // 确保数值字段是数字类型
  if (processedData.progress !== undefined) {
    processedData.progress = Number(processedData.progress);
  }
  
  if (processedData.frequency !== undefined && processedData.frequency !== null) {
    processedData.frequency = Number(processedData.frequency);
  }
  
  console.log('API - 发送创建请求数据:', processedData);
  
  return http.post('/api/fitness-goals', processedData)
    .then(response => {
      console.log('API - 健身目标创建成功:', response.data);
      return response.data;
    })
    .catch(error => {
      console.error('API - 创建健身目标失败:', {
        状态码: error.response ? error.response.status : '无状态码',
        错误信息: error.message,
        错误类型: error.name,
        响应数据: error.response ? JSON.stringify(error.response.data) : '无响应数据'
      });
      
      if (error.response?.status === 500) {
        const errorMsg = error.response?.data?.message || '';
        console.error('服务器错误详情:', errorMsg);
        
        if (errorMsg.includes('date') || errorMsg.includes('日期') || 
            errorMsg.includes('format') || errorMsg.includes('格式')) {
          throw new Error('日期格式错误，请检查开始日期和目标日期');
        }
      }
      
      throw error;
    });
}

/**
 * 更新健身目标
 * @param {number} id 健身目标ID
 * @param {Object} data 更新数据
 * @returns {Promise} 更新结果
 */
export function updateFitnessGoal(id, data) {
  console.log('API - 更新健身目标, ID:', id, ', 数据:', data);
  
  // 确保数据格式正确
  const processedData = { ...data };
  
  // 处理日期格式 - 使用符合后端@JsonFormat注解的格式
  ['startDate', 'targetDate', 'completedDate'].forEach(dateField => {
    if (processedData[dateField]) {
      try {
        // 确保日期是符合后端预期的格式 (yyyy-MM-dd HH:mm:ss)
        let dateStr = processedData[dateField];
        if (typeof dateStr === 'string') {
          // 处理带T的ISO格式
          if (dateStr.includes('T')) {
            dateStr = dateStr.replace('T', ' ').split('.')[0];
          }
          
          // 规范化日期格式
          const dateParts = dateStr.trim().split(' ');
          if (dateParts.length === 2) {
            processedData[dateField] = `${dateParts[0]} ${dateParts[1]}`;
          }
        }
      } catch (e) {
        console.warn(`API - 日期格式转换失败(${dateField}):`, e);
      }
    }
  });
  
  console.log('API - 发送更新请求数据:', processedData);
  
  return http.put(`/api/fitness-goals/${id}`, processedData)
    .then(response => {
      console.log('API - 健身目标更新成功:', response.data);
      return response.data;
    })
    .catch(error => {
      const errorDetails = {
        状态码: error.response ? error.response.status : '无状态码',
        错误信息: error.message,
        错误类型: error.name,
        响应数据: error.response ? error.response.data : '无响应数据',
        请求ID: id
      };
      
      console.error('API - 更新健身目标失败:', errorDetails);
      
      // Hibernate序列化错误特殊处理
      if (error.response?.status === 500) {
        const errorMsg = JSON.stringify(error.response?.data || {});
        if (errorMsg.includes('Hibernate') || errorMsg.includes('lazy') || 
            errorMsg.includes('proxy') || errorMsg.includes('serialize') ||
            errorMsg.includes('ByteBuddy')) {
          console.warn('API - 检测到可能的Hibernate序列化问题，尝试采用备选方案');
          
          // 如果服务端报Hibernate错误，尝试使用删除再创建的方式
          return http.delete(`/api/fitness-goals/${id}`)
            .then(() => {
              console.log('API - 已删除原目标，准备创建新目标');
              // 移除ID相关字段，避免冲突
              const createData = { ...processedData };
              delete createData.id;
              
              // 创建新目标
              return http.post('/api/fitness-goals', createData);
            })
            .then(response => {
              console.log('API - 通过重建方式成功更新健身目标:', response.data);
              return response.data;
            })
            .catch(recreateError => {
              console.error('API - 重建健身目标失败:', recreateError);
              throw recreateError;
            });
        }
      }
      
      throw error;
    });
}

/**
 * 删除健身目标
 * @param {number} id 健身目标ID
 * @returns {Promise} 删除结果
 */
export function deleteFitnessGoal(id) {
  return http.delete(`/api/fitness-goals/${id}`)
}

/**
 * 获取活跃的健身目标
 * @returns {Promise} 活跃的健身目标列表
 */
export function getActiveFitnessGoals() {
  return http.get('/api/fitness-goals/active')
}

/**
 * 获取已完成的健身目标
 * @returns {Promise} 已完成的健身目标列表
 */
export function getCompletedFitnessGoals() {
  return http.get('/api/fitness-goals/completed')
}

/**
 * 标记健身目标为完成
 * @param {number} id 健身目标ID
 * @returns {Promise} 更新结果
 */
export function markGoalAsCompleted(id) {
  return http.put(`/api/fitness-goals/${id}/complete`)
}

/**
 * 完成健身目标
 * @param {number} id 健身目标ID
 * @returns {Promise} 更新结果
 */
export function completeGoal(id) {
  return http.put(`/api/fitness-goals/${id}/complete`)
}

/**
 * 重置健身目标进度
 * @param {number} id 健身目标ID
 * @returns {Promise} 更新结果
 */
export function resetGoalProgress(id) {
  return http.put(`/api/fitness-goals/${id}/reset`)
}

/**
 * 更新健身目标进度
 * @param {number} id 健身目标ID
 * @param {number} progress 进度值
 * @returns {Promise} 更新结果
 */
export function updateGoalProgress(id, progress) {
  return http.put(`/api/fitness-goals/${id}/progress?progress=${progress}`)
}

/**
 * 获取按类型分组的健身目标统计
 * @returns {Promise} 健身目标统计数据
 */
export function getGoalStatsByType() {
  return http.get('/api/fitness-goals/stats/by-type')
}

/**
 * 获取健身目标完成率统计
 * @param {Object} params 查询参数，如timeRange=MONTH|YEAR
 * @returns {Promise} 健身目标完成率
 */
export function getGoalCompletionRate(params) {
  return http.get('/api/fitness-goals/stats/completion-rate', { params })
}

/**
 * 获取最近期限的健身目标
 * @param {number} limit 限制数量
 * @returns {Promise} 健身目标列表
 */
export function getUpcomingGoals(limit = 5) {
  return http.get('/api/fitness-goals/upcoming', { params: { limit } })
} 